#include "rulemanager.h"
#include "databasemanager.h"
#include <QJsonArray>
#include <QJsonObject>
#include <QDebug>
#include <QStandardPaths>
#include <QDir>

/**
 * @brief 构造函数
 * @param parent 父对象，默认为nullptr
 */
RuleManager::RuleManager(QObject *parent)
    : QObject(parent), m_dbManager(nullptr)
{
}

/**
 * @brief 添加规则
 * @param rule 要添加的规则
 */
void RuleManager::addRule(const Rule &rule)
{
    m_rules.append(rule);
    emit rulesChanged();
}

/**
 * @brief 更新规则
 * @param ruleName 要更新的规则名称
 * @param rule 更新后的规则
 */
void RuleManager::updateRule(const QString &ruleName, const Rule &rule)
{
    // 遍历规则列表，查找要更新的规则
    for (int i = 0; i < m_rules.size(); i++) {
        if (m_rules[i].getName() == ruleName) {
            m_rules[i] = rule;
            emit rulesChanged();
            return;
        }
    }
}

/**
 * @brief 删除规则
 * @param ruleName 要删除的规则名称
 */
void RuleManager::deleteRule(const QString &ruleName)
{
    // 遍历规则列表，查找要删除的规则
    for (int i = 0; i < m_rules.size(); i++) {
        if (m_rules[i].getName() == ruleName) {
            m_rules.removeAt(i);
            emit rulesChanged();
            return;
        }
    }
}

/**
 * @brief 清空所有规则
 */
void RuleManager::clearRules()
{
    m_rules.clear();
    emit rulesChanged();
}

/**
 * @brief 获取所有规则
 * @return 包含所有规则的列表
 */
QList<Rule> RuleManager::getAllRules() const
{
    return m_rules;
}

/**
 * @brief 根据名称获取规则
 * @param ruleName 规则名称
 * @return 匹配的规则，如果不存在则返回空规则
 */
Rule RuleManager::getRuleByName(const QString &ruleName) const
{
    // 遍历规则列表，查找匹配的规则
    for (const Rule &rule : m_rules) {
        if (rule.getName() == ruleName) {
            return rule;
        }
    }
    return Rule();
}

/**
 * @brief 将规则保存到文件
 * @param filename 文件名
 * @return 如果保存成功则返回true，否则返回false
 */
bool RuleManager::saveRulesToFile(const QString &filename) const
{
    // 打开文件进行写入
    QFile file(filename);
    if (!file.open(QIODevice::WriteOnly)) {
        qDebug() << "无法打开文件进行写入：" << filename;
        return false;
    }

    // 创建JSON数组，遍历所有规则并转换为JSON对象
    QJsonArray rulesArray;
    for (const Rule &rule : m_rules) {
        QJsonObject ruleObj;
        ruleObj["name"] = rule.getName();
        
        // 将规则条件转换为JSON数组
        QJsonArray conditionsArray;
        for (const QString &condition : rule.getConditions()) {
            conditionsArray.append(condition);
        }
        ruleObj["conditions"] = conditionsArray;
        ruleObj["conclusion"] = rule.getConclusion();
        ruleObj["priority"] = 1; // 默认优先级
        
        rulesArray.append(ruleObj);
    }

    // 创建JSON对象，将规则数组作为其属性
    QJsonObject rootObj;
    rootObj["rules"] = rulesArray;

    // 创建JSON文档并写入文件
    QJsonDocument doc(rootObj);
    file.write(doc.toJson());
    file.close();
    return true;
}

/**
 * @brief 从文件加载规则
 * @param filename 文件名
 * @return 如果加载成功则返回true，否则返回false
 */
bool RuleManager::loadRulesFromFile(const QString &filename)
{
    // 打开文件进行读取
    QFile file(filename);
    if (!file.open(QIODevice::ReadOnly)) {
        qDebug() << "无法打开文件进行读取：" << filename;
        return false;
    }

    // 读取文件内容并解析为JSON文档
    QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
    file.close();

    // 检查JSON文档是否为对象
    if (!doc.isObject()) {
        return false;
    }

    // 获取JSON对象和规则数组
    QJsonObject rootObj = doc.object();
    QJsonArray rulesArray = rootObj["rules"].toArray();

    // 清空现有规则
    m_rules.clear();

    // 遍历规则数组，逐个添加规则
    for (const QJsonValue &value : rulesArray) {
        QJsonObject ruleObj = value.toObject();
        QString name = ruleObj["name"].toString();
        QStringList conditions;
        
        // 解析规则条件
        QJsonArray conditionsArray = ruleObj["conditions"].toArray();
        for (const QJsonValue &condValue : conditionsArray) {
            conditions.append(condValue.toString());
        }
        
        QString conclusion = ruleObj["conclusion"].toString();
        
        // 创建规则并添加到规则列表
        Rule rule(name, conditions, conclusion);
        m_rules.append(rule);
    }
    
    emit rulesChanged();
    return true;
}

/**
 * @brief 设置数据库管理器
 * @param dbManager 数据库管理器指针
 */
void RuleManager::setDatabaseManager(DatabaseManager *dbManager)
{
    m_dbManager = dbManager;
}

/**
 * @brief 从数据库加载规则
 * @return 如果加载成功则返回true，否则返回false
 */
bool RuleManager::loadRulesFromDatabase()
{
    if (!m_dbManager) {
        qDebug() << "数据库管理器未设置";
        return false;
    }
    
    // 从数据库获取所有规则
    QList<QStringList> rulesData = m_dbManager->getAllRules();
    
    // 清空现有规则
    m_rules.clear();
    
    // 遍历规则数据，创建规则对象
    for (const QStringList &ruleData : rulesData) {
        if (ruleData.size() >= 2) {
            QString conditionsStr = ruleData[0];  // 规则条件
            QString conclusion = ruleData[1];     // 规则结论
            
            // 分割条件字符串
            QStringList conditions = conditionsStr.split(",", Qt::SkipEmptyParts);
            
            // 生成规则名称（基于条件和结论）
            QString name = QString("规则_%1").arg(m_rules.size() + 1);
            
            // 创建规则对象并添加到规则列表
            Rule rule(name, conditions, conclusion);
            m_rules.append(rule);
        }
    }
    
    emit rulesChanged();
    
    qDebug() << "从数据库加载规则完成，共加载" << m_rules.size() << "条规则，规则实际有" << rulesData.size() << "条";
    return true;
}

/**
 * @brief 获取所有规则类别
 * @return 包含所有规则类别的字符串列表
 * 
 * 简单实现：按规则名称前缀分类
 */
QStringList RuleManager::getRuleCategories() const
{
    QStringList categories;
    QSet<QString> categorySet;
    
    // 遍历所有规则，提取类别名称
    for (const Rule &rule : m_rules) {
        QString name = rule.getName();
        int colonIndex = name.indexOf(":");
        if (colonIndex > 0) {
            QString category = name.left(colonIndex);
            categorySet.insert(category);
        }
    }
    
    // 将集合转换为列表并排序
    categories = categorySet.values();
    categories.sort();
    return categories;
}

/**
 * @brief 根据类别获取规则
 * @param category 规则类别名称
 * @return 属于指定类别的规则列表
 */
QList<Rule> RuleManager::getRulesByCategory(const QString &category) const
{
    QList<Rule> result;
    
    // 遍历所有规则，查找属于指定类别的规则
    for (const Rule &rule : m_rules) {
        QString name = rule.getName();
        if (name.startsWith(category + ":")) {
            result.append(rule);
        }
    }
    
    return result;
}

/**
 * @brief 将规则添加到指定类别
 * @param rule 要添加的规则
 * @param category 规则类别名称
 */
void RuleManager::addRuleToCategory(const Rule &rule, const QString &category)
{
    // 创建一个带类别的新规则名称
    QString newRuleName = category + ":" + rule.getName();
    Rule newRule(newRuleName, rule.getConditions(), rule.getConclusion());
    addRule(newRule);
}